package com.itzjc.controller;

import com.itzjc.domain.entity.Result;
import com.itzjc.domain.pojo.*;
import com.itzjc.service.UploadService;
import com.itzjc.utils.POIUtils;
import com.itzjc.utils.QiNiuUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.math.BigInteger;
import java.util.*;

/**
 * 上传相关的controller
 *
 * @className: UploadController
 * @date: 2021-06-16 09:40
 **/
@RestController
@RequestMapping("/web/api/v1/pri/upload")
public class UploadController {
    @Autowired
    private UploadService uploadService;

    /**
     * 这里说明一下，这个controller没有进入到service，只是在本层就完成了图片的上传了
     * 真正修改数据库中的img的就到project的controller中去找
     * 上传的时候都是post请求，所以全部都需要拦截器放行，每写一个方法都配置一下
     *
     * @param imgFile
     * @return:
     **/

    @PostMapping("/uploadImg")
    //接受参数的时候没有注解的时候是接受不到参数的，这个注解的名称要和浏览器的对应上
    public Result uploadImg(@RequestParam("file") MultipartFile imgFile) {
        if (null != imgFile) {
            //获取原有的图片名称，截取后缀名
            String originalFilename = imgFile.getOriginalFilename();

            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));

            //生成唯一文件名称，拼接后缀
            String filename = UUID.randomUUID() + extension;
            //调用七牛API上传
            try {
                QiNiuUtils.uploadViaByte(imgFile.getBytes(), filename);

                //返回数据给页面
                Map<String, String> map = new HashMap<>();
                map.put("imgName", filename);
                map.put("domain", QiNiuUtils.DOMAIN);
                return Result.buildSuccess("上传成功", map);


            } catch (IOException e) {
                e.printStackTrace();
                return Result.buildError("上传失败", 300);
            }
        } else {
            return Result.buildError("请上传正确的文件");
        }


    }

    @PostMapping("/uploadObj")
    public Result uploadObj(@RequestParam("file") MultipartFile objFile) {
        if (null != objFile) {
            //获取原有的图片名称，截取后缀名
            String originalFilename = objFile.getOriginalFilename();

            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));

            //生成唯一文件名称，拼接后缀
            String filename = UUID.randomUUID() + extension;
            //调用七牛API上传
            try {
                QiNiuUtils.uploadViaByte(objFile.getBytes(), filename);

                //返回数据给页面
                Map<String, String> map = new HashMap<>();
                map.put("objName", filename);
                map.put("domain", QiNiuUtils.DOMAIN);
                return Result.buildSuccess("上传成功", map);


            } catch (IOException e) {
                e.printStackTrace();
                return Result.buildError("上传失败", 300);
            }
        } else {
            return Result.buildError("请上传正确的文件");
        }
    }

    @PostMapping("/uploadMtl")
    public Result uploadMtl(@RequestParam("file") MultipartFile mtlFile) {
        if (null != mtlFile) {
            //获取原有的文件名称，截取后缀名
            String originalFilename = mtlFile.getOriginalFilename();

            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));

            //生成唯一文件名称，拼接后缀
            String filename = UUID.randomUUID() + extension;
            //调用七牛API上传
            try {
                QiNiuUtils.uploadViaByte(mtlFile.getBytes(), filename);

                //返回数据给页面
                Map<String, String> map = new HashMap<>();
                map.put("mtlName", filename);
                map.put("domain", QiNiuUtils.DOMAIN);
                return Result.buildSuccess("上传成功", map);


            } catch (IOException e) {
                e.printStackTrace();
                return Result.buildError("上传失败", 300);
            }
        } else {
            return Result.buildError("请上传正确的文件");
        }
    }

    /**
     * 下面是单个数据的导入补充
     **/

    @PostMapping("/uploadDeflectionData")
    public Result uploadData(@RequestParam("file") MultipartFile dataFile, @RequestParam("pjId") String pjId1) {

        try {
            //解析文件
            List<String[]> strings = POIUtils.readExcel(dataFile);
            //转换
            List<DeflectionValue01> deflectionValue01s = new ArrayList<>();
            //创建上一步的数组的内部对象，存储每一次循环的值
            DeflectionValue01 dfv = null;
            for (String[] arr : strings) {
                // 每个遍历出的数组arr 代表着一行记录
                //这里存到数据库中的时间尽量保持为初始数值，以后需要调整的时候就调用相关的工具1953工具类就行了
                BigInteger createTime = new BigInteger(arr[0]);
                Double value = Double.valueOf(arr[1]);
                Integer sensorId = Integer.valueOf(arr[2]);
                Integer pjId = Integer.valueOf(pjId1);
                dfv = new DeflectionValue01(value, createTime, sensorId, pjId);
                deflectionValue01s.add(dfv);
            }

            //调用服务
            uploadService.addDeflectionData(deflectionValue01s);

            //返回结果
            return Result.buildSuccess("导入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        }

        return Result.buildError("导入数据失败", 300);
    }

    @PostMapping("/uploadDisplacementData")
    public Result uploadDisplacementData(@RequestParam("file") MultipartFile dataFile, @RequestParam("pjId") String pjId1) {
        try {
            //解析文件
            List<String[]> strings = POIUtils.readExcel(dataFile);
            //转换
            List<DispalcementValue01> dispalcementValue01s = new ArrayList<>();
            //创建上一步的数组的内部对象，存储每一次循环的值
            DispalcementValue01 dpv = null;
            for (String[] arr : strings) {
                // 每个遍历出的数组arr 代表着一行记录
                //这里存到数据库中的时间尽量保持为初始数值，以后需要调整的时候就调用相关的工具1953工具类就行了
                BigInteger createTime = new BigInteger(arr[0]);
                Double value = Double.valueOf(arr[1]);
                Integer sensorId = Integer.valueOf(arr[2]);
                Integer pjId = Integer.valueOf(pjId1);
                dpv = new DispalcementValue01(value, createTime, sensorId, pjId);
                dispalcementValue01s.add(dpv);
            }

            //调用服务
            uploadService.addDisplacementData(dispalcementValue01s);

            //返回结果
            return Result.buildSuccess("导入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.buildError("导入数据失败", 300);
    }

    @PostMapping("/uploadTemperatureData")
    public Result uploadTemperatureData(@RequestParam("file") MultipartFile dataFile, @RequestParam("pjId") String pjId1) {
        try {
            //解析文件
            List<String[]> strings = POIUtils.readExcel(dataFile);
            //转换
            List<TemperatureValue01> temperatureValue01s = new ArrayList<>();
            //创建上一步的数组的内部对象，存储每一次循环的值
            TemperatureValue01 tv = null;
            for (String[] arr : strings) {
                // 每个遍历出的数组arr 代表着一行记录
                //这里存到数据库中的时间尽量保持为初始数值，以后需要调整的时候就调用相关的工具1953工具类就行了
                BigInteger createTime = new BigInteger(arr[0]);
                Double value = Double.valueOf(arr[1]);
                Integer sensorId = Integer.valueOf(arr[2]);
                Integer pjId = Integer.valueOf(pjId1);
                tv = new TemperatureValue01(value, createTime, sensorId, pjId);
                temperatureValue01s.add(tv);
            }

            //调用服务
            uploadService.addTemperatureData(temperatureValue01s);

            //返回结果
            return Result.buildSuccess("导入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.buildError("导入数据失败", 300);
    }

    @PostMapping("/uploadStressData")
    public Result uploadStressData(@RequestParam("file") MultipartFile dataFile, @RequestParam("pjId") String pjId1) {
        try {
            //解析文件
            List<String[]> strings = POIUtils.readExcel(dataFile);
            //转换
            List<StressValue01> stressValue01s = new ArrayList<>();
            //创建上一步的数组的内部对象，存储每一次循环的值
            StressValue01 stressValue01 = null;
            for (String[] arr : strings) {
                // 每个遍历出的数组arr 代表着一行记录
                //这里存到数据库中的时间尽量保持为初始数值，以后需要调整的时候就调用相关的工具1953工具类就行了
                BigInteger createTime = new BigInteger(arr[0]);
                Double value = Double.valueOf(arr[1]);
                Integer sensorId = Integer.valueOf(arr[2]);
                Integer pjId = Integer.valueOf(pjId1);
                stressValue01 = new StressValue01(value, createTime, sensorId, pjId);
                stressValue01s.add(stressValue01);
            }

            //调用服务
            uploadService.addStressData(stressValue01s);

            //返回结果
            return Result.buildSuccess("导入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.buildError("导入数据失败", 300);
    }

    @PostMapping("/uploadWindData")
    public Result uploadWindData(@RequestParam("file") MultipartFile dataFile, @RequestParam("pjId") String pjId1) {
        try {
            //解析文件
            List<String[]> strings = POIUtils.readExcel(dataFile);
            //转换
            List<WindValue01> windValue01s = new ArrayList<>();
            //创建上一步的数组的内部对象，存储每一次循环的值
            WindValue01 windValue01 = null;
            for (String[] arr : strings) {
                // 每个遍历出的数组arr 代表着一行记录
                //这里存到数据库中的时间尽量保持为初始数值，以后需要调整的时候就调用相关的工具1953工具类就行了
                BigInteger createTime = new BigInteger(arr[0]);
                Double value = Double.valueOf(arr[1]);
                Integer sensorId = Integer.valueOf(arr[2]);
                Integer pjId = Integer.valueOf(pjId1);
                windValue01 = new WindValue01(value, createTime, sensorId, pjId);
                windValue01s.add(windValue01);
            }

            //调用服务
            uploadService.addWindData(windValue01s);

            //返回结果
            return Result.buildSuccess("导入数据成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.buildError("导入数据失败", 300);
    }


    /**
     * 关系表的导入
     *
     **/


}
